// 使用闭包实现真正的私有构造函数
// const bluetooth_class = (function () {
//   let instance = null

//   class BluetoothClass {
//     constructor(bluetoothStatus = { a: 1, b: 2 }) {
//       if (instance) {
//         return instance
//       }

//       this.bluetoothStatus = bluetoothStatus
//       this.isNotify = false
//       this.notifyCount = 0

//       instance = this
//     }

//     static getInstance() {
//       if (!instance) {
//         instance = new BluetoothClass()
//       }
//       return instance
//     }
//   }

//   return BluetoothClass
// })()
// // const a1 = bluetooth_class.getInstance()
// const a2 = new bluetooth_class({ a: 1, b: 2 })
// // console.log(a1 === a2)
// console.log(a2.bluetoothStatus)
// console.log(JSON.parse(JSON.stringify(undefined || {})))

// function formatVal(n) {
//   let hex = n.length % 2 ? '0' + n : n
//   return hex
//     .split(/(.{2})/g)
//     .filter((v) => v)
//     .reverse()
// }
// const HexCalculator = {
//   /**
//    * 解析输入参数为十进制数值
//    * @param {string|string[]} input - 输入参数
//    * @returns {number} 十进制数值
//    */
//   parseInput: function (input) {
//     if (Array.isArray(input)) {
//       // 如果是数组，合并为完整十六进制字符串
//       return parseInt(input.join(''), 16)
//     } else {
//       // 如果是字符串，直接解析
//       return parseInt(input, 16)
//     }
//   },
//   /**
//    * 格式化十六进制值为2位字符串的数组
//    * @param {string|number} hex - string:十六进制值 | number:十进制值
//    * @returns {string[]} 2位字符串的数组
//    */
//   formatHexArray: function (hex) {
//     let hexStr = typeof hex === 'number' ? hex.toString(16) : hex
//     hexStr = hexStr.length % 2 ? '0' + hexStr : hexStr
//     return hexStr.split(/(.{2})/g).filter((v) => v)
//   },
//   /**
//    * 在数组前面填充指定数量的指定元素
//    * @param {string[]} array - 原始数组
//    * @param {number} length - 需要填充到的长度
//    * @param {string} fillValue - 填充值，默认为'00'
//    * @returns {string[]} 填充后的数组
//    */
//   padStartArray: function (array, length, fillValue = '00') {
//     const fillCount = length - array.length
//     if (fillCount < 0) {
//       throw new Error('数组长度已经大于指定长度')
//       // return array
//     }
//     // 创建填充数组
//     const padding = Array(fillCount).fill(fillValue)
//     // 合并填充数组和原数组
//     return [...padding, ...array]
//   },

//   /**
//    * 加法运算
//    * @param {string|string[]} h1 - 第一个十六进制值
//    * @param {string|string[]} h2 - 第二个十六进制值
//    * @param {Boolean|Number} format - 是否格式化 false不格式化 true格式化为2位字符串的数组 number指定长度的数组
//    * @returns {string|string[]} 十六进制字符串 或 2位字符串的 指定长度数组
//    */
//   add: function (h1, h2, format = 2) {
//     const val1 = this.parseInput(h1)
//     const val2 = this.parseInput(h2)
//     const result = val1 + val2
//     if (format) {
//       const res = this.formatHexArray(result.toString(16))
//       if (format == true) {
//         return res
//       } else {
//         this.padStartArray(res, format)
//       }
//     } else {
//       return result.toString(16)
//     }
//   },

//   /**
//    * 减法运算
//    * @param {string|string[]} h1 - 第一个十六进制值
//    * @param {string|string[]} h2 - 第二个十六进制值
//    * @param {Boolean|Number} format - 是否格式化 false不格式化 true格式化为2位字符串的数组 number指定长度的数组
//    * @returns {string|string[]} 十六进制字符串 或 2位字符串的 指定长度数组
//    */
//   subtract: function (h1, h2, format = 2) {
//     const val1 = this.parseInput(h1)
//     const val2 = this.parseInput(h2)
//     const result = val1 - val2
//     if (format) {
//       const res = this.formatHexArray(result.toString(16))
//       if (format == true) {
//         return res
//       } else {
//         this.padStartArray(res, format)
//       }
//     } else {
//       return result.toString(16)
//     }
//   },

//   /**
//    * 乘法运算
//    * @param {string|string[]} h1 - 第一个十六进制值
//    * @param {string|string[]} h2 - 第二个十六进制值
//    * @param {Boolean|Number} format - 是否格式化 false不格式化 true格式化为2位字符串的数组 number指定长度的数组
//    * @returns {string|string[]} 十六进制字符串 或 2位字符串的 指定长度数组
//    */
//   multiply: function (h1, h2, format = 2) {
//     const val1 = this.parseInput(h1)
//     const val2 = this.parseInput(h2)
//     const result = val1 * val2
//     if (format) {
//       const res = this.formatHexArray(result.toString(16))
//       if (format == true) {
//         return res
//       } else {
//         this.padStartArray(res, format)
//       }
//     } else {
//       return result.toString(16)
//     }
//   },

//   /**
//    * 除法运算
//    * @param {string|string[]} h1 - 第一个十六进制值
//    * @param {string|string[]} h2 - 第二个十六进制值
//    * @param {Boolean|Number} format - 是否格式化 false不格式化 true格式化为2位字符串的数组 number指定长度的数组
//    * @returns {string|string[]} 十六进制字符串 或 2位字符串的 指定长度数组
//    */
//   divide: function (h1, h2, format = 2) {
//     const val1 = this.parseInput(h1)
//     const val2 = this.parseInput(h2)
//     const result = Math.floor(val1 / val2) // 整数除法
//     if (format) {
//       const res = this.formatHexArray(result.toString(16))
//       if (format == true) {
//         return res
//       } else {
//         this.padStartArray(res, format)
//       }
//     } else {
//       return result.toString(16)
//     }
//   },
// }

/**
 * 写入模式命令 --Sx、Mx起始寄存器地址
 * @template T - 返回对象的类型
 * @param {String} type - 模式类型字符串，如 'A1M1'
 * @returns {T} 返回包含模式配置的对象
 * @returns {string} T.mode - 模式名称 (如 'MN')
 * @returns {string[]} T.reg - 寄存器地址数组
 * @returns {string[]} T.regNum - 寄存器数量数组
 * @returns {string} T.len - 数据长度
 * @example writeModeCmd('A1M1')
 */

/**
 * 写入模式命令 --Sx、Mx起始寄存器地址
 * @param {String} type - 模式类型字符串，如 'A1M1'
 * @returns obj 返回包含模式配置的对象
 * @returns {string} obj.mode - 模式名称 (如 'MN')
 * @returns {string[]} obj.reg - 寄存器地址数组
 * @returns {string[]} obj.regNum - 寄存器数量数组
 * @returns {string} obj.len - 数据长度
 * @example writeModeCmd('A1M1')
 */

/**
 * @param {Object[]} orders 工单列表
 * @param {String} orders[].worktype 工单类型
 * @param {Number} orders[].target_tork 目标扭矩值
 * @param {Number} orders[].max_tork 最大扭矩值
 * @param {Number} orders[].min_tork 最小扭矩值
 * @param {Number} orders[].angle 目标角度值
 * @param {Number} orders[].max_angle 最大角度值
 * @param {Number} orders[].min_angle 最小角度值
 * @returns 指令列表
 */

// const a = '01 10 06 49 00 03 06 00 00 00 14 00 6E'
// console.log(a.split(' '))
// console.log(Array(10).fill(['00', '00', '00', '00']))
// const padding = Array(NaN).fill('00')
// 合并填充数组和原数组
// console.log(NaN ? true : false)
// function a(...args) {
//   console.log(arguments)
//   console.log(args)
// }

// let i = 0
// function setIntervalImmediate(func, delay, ...args) {
//   // 立即执行一次
//   func.apply(null, args)
//   // 返回 setInterval 的 ID 以便后续清除
//   return setInterval(func, delay, ...args)
// }

// // 使用示例
// let t = setIntervalImmediate(() => {
//   console.log('立即执行并每隔1秒执行一次')
//   if (i++ > 5) {
//     clearInterval(t)
//   }
// }, 1000)

// 清除定时器
// clearInterval(i)
